#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_luaQColor_open (lua_State* tolua_S);

#include "./../luaQt.h"
#include "./../luaQColor.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_QColor (lua_State* tolua_S)
{
 QColor* self = (QColor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QStringList (lua_State* tolua_S)
{
 QStringList* self = (QStringList*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QString (lua_State* tolua_S)
{
 QString* self = (QString*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QRgb (lua_State* tolua_S)
{
 QRgb* self = (QRgb*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QVariant (lua_State* tolua_S)
{
 QVariant* self = (QVariant*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QRgba64 (lua_State* tolua_S)
{
 QRgba64* self = (QRgba64*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"QColor");
 tolua_usertype(tolua_S,"Qt::GlobalColor");
 tolua_usertype(tolua_S,"QStringList");
 tolua_usertype(tolua_S,"QString");
 tolua_usertype(tolua_S,"QRgb");
 tolua_usertype(tolua_S,"QVariant");
 tolua_usertype(tolua_S,"QRgba64");
 tolua_usertype(tolua_S,"QLatin1String");
}

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new00
static int tolua_luaQColor_QColor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new00_local
static int tolua_luaQColor_QColor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new01
static int tolua_luaQColor_QColor_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Qt::GlobalColor",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Qt::GlobalColor color = *((Qt::GlobalColor*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(color));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new01_local
static int tolua_luaQColor_QColor_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Qt::GlobalColor",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Qt::GlobalColor color = *((Qt::GlobalColor*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(color));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new02
static int tolua_luaQColor_QColor_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int g = ((int)  tolua_tonumber(tolua_S,3,0));
  int b = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(r,g,b,a));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new02_local
static int tolua_luaQColor_QColor_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int g = ((int)  tolua_tonumber(tolua_S,3,0));
  int b = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(r,g,b,a));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new03
static int tolua_luaQColor_QColor_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QRgb rgb = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(rgb));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new03_local
static int tolua_luaQColor_QColor_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QRgb rgb = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(rgb));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new04
static int tolua_luaQColor_QColor_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgba64",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QRgba64 rgba64 = *((QRgba64*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(rgba64));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new04_local
static int tolua_luaQColor_QColor_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgba64",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QRgba64 rgba64 = *((QRgba64*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(rgba64));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new05
static int tolua_luaQColor_QColor_new05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* name = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(*name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new05_local
static int tolua_luaQColor_QColor_new05_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* name = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(*name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new04_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new06
static int tolua_luaQColor_QColor_new06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* aname = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(aname));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new06_local
static int tolua_luaQColor_QColor_new06_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* aname = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(aname));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new05_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new07
static int tolua_luaQColor_QColor_new07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String name = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new07_local
static int tolua_luaQColor_QColor_new07_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String name = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new06_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new08
static int tolua_luaQColor_QColor_new08(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QColor::Spec spec = ((QColor::Spec) (int)  tolua_tonumber(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(spec));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new07(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_new08_local
static int tolua_luaQColor_QColor_new08_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QColor::Spec spec = ((QColor::Spec) (int)  tolua_tonumber(tolua_S,2,0));
  {
   QColor* tolua_ret = (QColor*)  Mtolua_new((QColor)(spec));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_new07_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isValid of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_isValid00
static int tolua_luaQColor_QColor_isValid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isValid'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isValid();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isValid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: name of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_name00
static int tolua_luaQColor_QColor_name00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->name();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: name of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_name01
static int tolua_luaQColor_QColor_name01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  QColor::NameFormat format = ((QColor::NameFormat) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->name(format);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_name00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNamedColor of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setNamedColor00
static int tolua_luaQColor_QColor_setNamedColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  const QString* name = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNamedColor'", NULL);
#endif
  {
   self->setNamedColor(*name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNamedColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNamedColor of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setNamedColor01
static int tolua_luaQColor_QColor_setNamedColor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String name = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNamedColor'", NULL);
#endif
  {
   self->setNamedColor(name);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQColor_QColor_setNamedColor00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: colorNames of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_colorNames00
static int tolua_luaQColor_QColor_colorNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'colorNames'", NULL);
#endif
  {
   QStringList tolua_ret = (QStringList)  self->colorNames();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'colorNames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: alpha of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_alpha00
static int tolua_luaQColor_QColor_alpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'alpha'", NULL);
#endif
  {
   int tolua_ret = (int)  self->alpha();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'alpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlpha of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setAlpha00
static int tolua_luaQColor_QColor_setAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int alpha = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlpha'", NULL);
#endif
  {
   self->setAlpha(alpha);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: alphaF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_alphaF00
static int tolua_luaQColor_QColor_alphaF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'alphaF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->alphaF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'alphaF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlphaF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setAlphaF00
static int tolua_luaQColor_QColor_setAlphaF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double alpha = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlphaF'", NULL);
#endif
  {
   self->setAlphaF(alpha);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlphaF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: red of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_red00
static int tolua_luaQColor_QColor_red00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'red'", NULL);
#endif
  {
   int tolua_ret = (int)  self->red();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'red'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: green of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_green00
static int tolua_luaQColor_QColor_green00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'green'", NULL);
#endif
  {
   int tolua_ret = (int)  self->green();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'green'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: blue of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_blue00
static int tolua_luaQColor_QColor_blue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'blue'", NULL);
#endif
  {
   int tolua_ret = (int)  self->blue();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'blue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRed of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRed00
static int tolua_luaQColor_QColor_setRed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int red = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRed'", NULL);
#endif
  {
   self->setRed(red);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGreen of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setGreen00
static int tolua_luaQColor_QColor_setGreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int green = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGreen'", NULL);
#endif
  {
   self->setGreen(green);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBlue of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setBlue00
static int tolua_luaQColor_QColor_setBlue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int blue = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBlue'", NULL);
#endif
  {
   self->setBlue(blue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBlue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: redF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_redF00
static int tolua_luaQColor_QColor_redF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'redF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->redF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'redF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: greenF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_greenF00
static int tolua_luaQColor_QColor_greenF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'greenF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->greenF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'greenF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: blueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_blueF00
static int tolua_luaQColor_QColor_blueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'blueF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->blueF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'blueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRedF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRedF00
static int tolua_luaQColor_QColor_setRedF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double red = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRedF'", NULL);
#endif
  {
   self->setRedF(red);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRedF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGreenF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setGreenF00
static int tolua_luaQColor_QColor_setGreenF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double green = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGreenF'", NULL);
#endif
  {
   self->setGreenF(green);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGreenF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBlueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setBlueF00
static int tolua_luaQColor_QColor_setBlueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double blue = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBlueF'", NULL);
#endif
  {
   self->setBlueF(blue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBlueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getRgb00
static int tolua_luaQColor_QColor_getRgb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int g = ((int)  tolua_tonumber(tolua_S,3,0));
  int b = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRgb'", NULL);
#endif
  {
   self->getRgb(&r,&g,&b,&a);
   tolua_pushnumber(tolua_S,(lua_Number)r);
   tolua_pushnumber(tolua_S,(lua_Number)g);
   tolua_pushnumber(tolua_S,(lua_Number)b);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRgb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRgb00
static int tolua_luaQColor_QColor_setRgb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int g = ((int)  tolua_tonumber(tolua_S,3,0));
  int b = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRgb'", NULL);
#endif
  {
   self->setRgb(r,g,b,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRgb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRgbF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getRgbF00
static int tolua_luaQColor_QColor_getRgbF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double r = ((double)  tolua_tonumber(tolua_S,2,0));
  double g = ((double)  tolua_tonumber(tolua_S,3,0));
  double b = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRgbF'", NULL);
#endif
  {
   self->getRgbF(&r,&g,&b,&a);
   tolua_pushnumber(tolua_S,(lua_Number)r);
   tolua_pushnumber(tolua_S,(lua_Number)g);
   tolua_pushnumber(tolua_S,(lua_Number)b);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRgbF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRgbF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRgbF00
static int tolua_luaQColor_QColor_setRgbF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double r = ((double)  tolua_tonumber(tolua_S,2,0));
  double g = ((double)  tolua_tonumber(tolua_S,3,0));
  double b = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRgbF'", NULL);
#endif
  {
   self->setRgbF(r,g,b,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRgbF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rgba64 of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_rgba6400
static int tolua_luaQColor_QColor_rgba6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rgba64'", NULL);
#endif
  {
   QRgba64 tolua_ret = (QRgba64)  self->rgba64();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QRgba64)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgba64");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QRgba64));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgba64");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rgba64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRgba64 of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRgba6400
static int tolua_luaQColor_QColor_setRgba6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgba64",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  QRgba64 rgba = *((QRgba64*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRgba64'", NULL);
#endif
  {
   self->setRgba64(rgba);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRgba64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rgba of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_rgba00
static int tolua_luaQColor_QColor_rgba00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rgba'", NULL);
#endif
  {
   QRgb tolua_ret = (QRgb)  self->rgba();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QRgb)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgb");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QRgb));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgb");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rgba'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRgba of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRgba00
static int tolua_luaQColor_QColor_setRgba00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  QRgb rgba = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRgba'", NULL);
#endif
  {
   self->setRgba(rgba);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRgba'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_rgb00
static int tolua_luaQColor_QColor_rgb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rgb'", NULL);
#endif
  {
   QRgb tolua_ret = (QRgb)  self->rgb();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QRgb)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgb");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QRgb));
     tolua_pushusertype(tolua_S,tolua_obj,"QRgb");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rgb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setRgb01
static int tolua_luaQColor_QColor_setRgb01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  QRgb rgb = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRgb'", NULL);
#endif
  {
   self->setRgb(rgb);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQColor_QColor_setRgb00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: hue of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hue00
static int tolua_luaQColor_QColor_hue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hue'", NULL);
#endif
  {
   int tolua_ret = (int)  self->hue();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saturation of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_saturation00
static int tolua_luaQColor_QColor_saturation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saturation'", NULL);
#endif
  {
   int tolua_ret = (int)  self->saturation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saturation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hsvHue of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hsvHue00
static int tolua_luaQColor_QColor_hsvHue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hsvHue'", NULL);
#endif
  {
   int tolua_ret = (int)  self->hsvHue();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hsvHue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hsvSaturation of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hsvSaturation00
static int tolua_luaQColor_QColor_hsvSaturation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hsvSaturation'", NULL);
#endif
  {
   int tolua_ret = (int)  self->hsvSaturation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hsvSaturation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: value of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_value00
static int tolua_luaQColor_QColor_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'value'", NULL);
#endif
  {
   int tolua_ret = (int)  self->value();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hueF00
static int tolua_luaQColor_QColor_hueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hueF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->hueF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saturationF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_saturationF00
static int tolua_luaQColor_QColor_saturationF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saturationF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->saturationF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saturationF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hsvHueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hsvHueF00
static int tolua_luaQColor_QColor_hsvHueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hsvHueF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->hsvHueF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hsvHueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hsvSaturationF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hsvSaturationF00
static int tolua_luaQColor_QColor_hsvSaturationF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hsvSaturationF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->hsvSaturationF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hsvSaturationF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: valueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_valueF00
static int tolua_luaQColor_QColor_valueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'valueF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->valueF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'valueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHsv of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getHsv00
static int tolua_luaQColor_QColor_getHsv00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int v = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHsv'", NULL);
#endif
  {
   self->getHsv(&h,&s,&v,&a);
   tolua_pushnumber(tolua_S,(lua_Number)h);
   tolua_pushnumber(tolua_S,(lua_Number)s);
   tolua_pushnumber(tolua_S,(lua_Number)v);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHsv'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHsv of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setHsv00
static int tolua_luaQColor_QColor_setHsv00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int v = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHsv'", NULL);
#endif
  {
   self->setHsv(h,s,v,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHsv'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHsvF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getHsvF00
static int tolua_luaQColor_QColor_getHsvF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double v = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHsvF'", NULL);
#endif
  {
   self->getHsvF(&h,&s,&v,&a);
   tolua_pushnumber(tolua_S,(lua_Number)h);
   tolua_pushnumber(tolua_S,(lua_Number)s);
   tolua_pushnumber(tolua_S,(lua_Number)v);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHsvF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHsvF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setHsvF00
static int tolua_luaQColor_QColor_setHsvF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double v = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHsvF'", NULL);
#endif
  {
   self->setHsvF(h,s,v,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHsvF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cyan of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_cyan00
static int tolua_luaQColor_QColor_cyan00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cyan'", NULL);
#endif
  {
   int tolua_ret = (int)  self->cyan();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cyan'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: magenta of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_magenta00
static int tolua_luaQColor_QColor_magenta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'magenta'", NULL);
#endif
  {
   int tolua_ret = (int)  self->magenta();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'magenta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: yellow of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_yellow00
static int tolua_luaQColor_QColor_yellow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yellow'", NULL);
#endif
  {
   int tolua_ret = (int)  self->yellow();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'yellow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: black of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_black00
static int tolua_luaQColor_QColor_black00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'black'", NULL);
#endif
  {
   int tolua_ret = (int)  self->black();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'black'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cyanF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_cyanF00
static int tolua_luaQColor_QColor_cyanF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cyanF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->cyanF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cyanF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: magentaF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_magentaF00
static int tolua_luaQColor_QColor_magentaF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'magentaF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->magentaF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'magentaF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: yellowF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_yellowF00
static int tolua_luaQColor_QColor_yellowF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yellowF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->yellowF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'yellowF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: blackF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_blackF00
static int tolua_luaQColor_QColor_blackF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'blackF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->blackF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'blackF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCmyk of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getCmyk00
static int tolua_luaQColor_QColor_getCmyk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int c = ((int)  tolua_tonumber(tolua_S,2,0));
  int m = ((int)  tolua_tonumber(tolua_S,3,0));
  int y = ((int)  tolua_tonumber(tolua_S,4,0));
  int k = ((int)  tolua_tonumber(tolua_S,5,0));
  int a = ((int)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCmyk'", NULL);
#endif
  {
   self->getCmyk(&c,&m,&y,&k,&a);
   tolua_pushnumber(tolua_S,(lua_Number)c);
   tolua_pushnumber(tolua_S,(lua_Number)m);
   tolua_pushnumber(tolua_S,(lua_Number)y);
   tolua_pushnumber(tolua_S,(lua_Number)k);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 5;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCmyk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCmyk of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setCmyk00
static int tolua_luaQColor_QColor_setCmyk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int c = ((int)  tolua_tonumber(tolua_S,2,0));
  int m = ((int)  tolua_tonumber(tolua_S,3,0));
  int y = ((int)  tolua_tonumber(tolua_S,4,0));
  int k = ((int)  tolua_tonumber(tolua_S,5,0));
  int a = ((int)  tolua_tonumber(tolua_S,6,255));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCmyk'", NULL);
#endif
  {
   self->setCmyk(c,m,y,k,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCmyk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCmykF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getCmykF00
static int tolua_luaQColor_QColor_getCmykF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double c = ((double)  tolua_tonumber(tolua_S,2,0));
  double m = ((double)  tolua_tonumber(tolua_S,3,0));
  double y = ((double)  tolua_tonumber(tolua_S,4,0));
  double k = ((double)  tolua_tonumber(tolua_S,5,0));
  double a = ((double)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCmykF'", NULL);
#endif
  {
   self->getCmykF(&c,&m,&y,&k,&a);
   tolua_pushnumber(tolua_S,(lua_Number)c);
   tolua_pushnumber(tolua_S,(lua_Number)m);
   tolua_pushnumber(tolua_S,(lua_Number)y);
   tolua_pushnumber(tolua_S,(lua_Number)k);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 5;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCmykF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCmykF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setCmykF00
static int tolua_luaQColor_QColor_setCmykF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double c = ((double)  tolua_tonumber(tolua_S,2,0));
  double m = ((double)  tolua_tonumber(tolua_S,3,0));
  double y = ((double)  tolua_tonumber(tolua_S,4,0));
  double k = ((double)  tolua_tonumber(tolua_S,5,0));
  double a = ((double)  tolua_tonumber(tolua_S,6,1.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCmykF'", NULL);
#endif
  {
   self->setCmykF(c,m,y,k,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCmykF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hslHue of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hslHue00
static int tolua_luaQColor_QColor_hslHue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hslHue'", NULL);
#endif
  {
   int tolua_ret = (int)  self->hslHue();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hslHue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hslSaturation of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hslSaturation00
static int tolua_luaQColor_QColor_hslSaturation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hslSaturation'", NULL);
#endif
  {
   int tolua_ret = (int)  self->hslSaturation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hslSaturation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lightness of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_lightness00
static int tolua_luaQColor_QColor_lightness00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lightness'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lightness();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lightness'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hslHueF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hslHueF00
static int tolua_luaQColor_QColor_hslHueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hslHueF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->hslHueF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hslHueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hslSaturationF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_hslSaturationF00
static int tolua_luaQColor_QColor_hslSaturationF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hslSaturationF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->hslSaturationF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hslSaturationF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lightnessF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_lightnessF00
static int tolua_luaQColor_QColor_lightnessF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lightnessF'", NULL);
#endif
  {
   double tolua_ret = (double)  self->lightnessF();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lightnessF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHsl of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getHsl00
static int tolua_luaQColor_QColor_getHsl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int l = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHsl'", NULL);
#endif
  {
   self->getHsl(&h,&s,&l,&a);
   tolua_pushnumber(tolua_S,(lua_Number)h);
   tolua_pushnumber(tolua_S,(lua_Number)s);
   tolua_pushnumber(tolua_S,(lua_Number)l);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHsl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHsl of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setHsl00
static int tolua_luaQColor_QColor_setHsl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int l = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHsl'", NULL);
#endif
  {
   self->setHsl(h,s,l,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHsl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHslF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_getHslF00
static int tolua_luaQColor_QColor_getHslF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double l = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHslF'", NULL);
#endif
  {
   self->getHslF(&h,&s,&l,&a);
   tolua_pushnumber(tolua_S,(lua_Number)h);
   tolua_pushnumber(tolua_S,(lua_Number)s);
   tolua_pushnumber(tolua_S,(lua_Number)l);
   tolua_pushnumber(tolua_S,(lua_Number)a);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHslF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHslF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_setHslF00
static int tolua_luaQColor_QColor_setHslF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QColor* self = (QColor*)  tolua_tousertype(tolua_S,1,0);
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double l = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHslF'", NULL);
#endif
  {
   self->setHslF(h,s,l,a);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHslF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_toRgb00
static int tolua_luaQColor_QColor_toRgb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toRgb'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->toRgb();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toRgb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toHsv of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_toHsv00
static int tolua_luaQColor_QColor_toHsv00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toHsv'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->toHsv();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toHsv'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toCmyk of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_toCmyk00
static int tolua_luaQColor_QColor_toCmyk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toCmyk'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->toCmyk();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toCmyk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toHsl of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_toHsl00
static int tolua_luaQColor_QColor_toHsl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toHsl'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->toHsl();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toHsl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: convertTo of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_convertTo00
static int tolua_luaQColor_QColor_convertTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  QColor::Spec colorSpec = ((QColor::Spec) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'convertTo'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->convertTo(colorSpec);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'convertTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgb00
static int tolua_luaQColor_QColor_fromRgb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QRgb rgb = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgb(rgb);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromRgb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgba of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgba00
static int tolua_luaQColor_QColor_fromRgba00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgb",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QRgb rgba = *((QRgb*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgba(rgba);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromRgba'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgb of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgb01
static int tolua_luaQColor_QColor_fromRgb01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int g = ((int)  tolua_tonumber(tolua_S,3,0));
  int b = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgb(r,g,b,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_fromRgb00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgbF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgbF00
static int tolua_luaQColor_QColor_fromRgbF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double r = ((double)  tolua_tonumber(tolua_S,2,0));
  double g = ((double)  tolua_tonumber(tolua_S,3,0));
  double b = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgbF(r,g,b,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromRgbF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgba64 of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgba6400
static int tolua_luaQColor_QColor_fromRgba6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned short r = ((unsigned short)  tolua_tonumber(tolua_S,2,0));
  unsigned short g = ((unsigned short)  tolua_tonumber(tolua_S,3,0));
  unsigned short b = ((unsigned short)  tolua_tonumber(tolua_S,4,0));
  unsigned short a = ((unsigned short)  tolua_tonumber(tolua_S,5,USHRT_MAX));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgba64(r,g,b,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromRgba64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRgba64 of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromRgba6401
static int tolua_luaQColor_QColor_fromRgba6401(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRgba64",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QRgba64 rgba = *((QRgba64*)  tolua_tousertype(tolua_S,2,0));
  {
   QColor tolua_ret = (QColor)  QColor::fromRgba64(rgba);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_fromRgba6400(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromHsv of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromHsv00
static int tolua_luaQColor_QColor_fromHsv00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int v = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
  {
   QColor tolua_ret = (QColor)  QColor::fromHsv(h,s,v,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromHsv'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromHsvF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromHsvF00
static int tolua_luaQColor_QColor_fromHsvF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double v = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
  {
   QColor tolua_ret = (QColor)  QColor::fromHsvF(h,s,v,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromHsvF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromCmyk of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromCmyk00
static int tolua_luaQColor_QColor_fromCmyk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int c = ((int)  tolua_tonumber(tolua_S,2,0));
  int m = ((int)  tolua_tonumber(tolua_S,3,0));
  int y = ((int)  tolua_tonumber(tolua_S,4,0));
  int k = ((int)  tolua_tonumber(tolua_S,5,0));
  int a = ((int)  tolua_tonumber(tolua_S,6,255));
  {
   QColor tolua_ret = (QColor)  QColor::fromCmyk(c,m,y,k,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromCmyk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromCmykF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromCmykF00
static int tolua_luaQColor_QColor_fromCmykF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double c = ((double)  tolua_tonumber(tolua_S,2,0));
  double m = ((double)  tolua_tonumber(tolua_S,3,0));
  double y = ((double)  tolua_tonumber(tolua_S,4,0));
  double k = ((double)  tolua_tonumber(tolua_S,5,0));
  double a = ((double)  tolua_tonumber(tolua_S,6,1.0));
  {
   QColor tolua_ret = (QColor)  QColor::fromCmykF(c,m,y,k,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromCmykF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromHsl of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromHsl00
static int tolua_luaQColor_QColor_fromHsl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int h = ((int)  tolua_tonumber(tolua_S,2,0));
  int s = ((int)  tolua_tonumber(tolua_S,3,0));
  int l = ((int)  tolua_tonumber(tolua_S,4,0));
  int a = ((int)  tolua_tonumber(tolua_S,5,255));
  {
   QColor tolua_ret = (QColor)  QColor::fromHsl(h,s,l,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromHsl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromHslF of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_fromHslF00
static int tolua_luaQColor_QColor_fromHslF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double h = ((double)  tolua_tonumber(tolua_S,2,0));
  double s = ((double)  tolua_tonumber(tolua_S,3,0));
  double l = ((double)  tolua_tonumber(tolua_S,4,0));
  double a = ((double)  tolua_tonumber(tolua_S,5,1.0));
  {
   QColor tolua_ret = (QColor)  QColor::fromHslF(h,s,l,a);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromHslF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: light of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_light00
static int tolua_luaQColor_QColor_light00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int f = ((int)  tolua_tonumber(tolua_S,2,150));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->light(f);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'light'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lighter of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_lighter00
static int tolua_luaQColor_QColor_lighter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int f = ((int)  tolua_tonumber(tolua_S,2,150));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lighter'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->lighter(f);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lighter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dark of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_dark00
static int tolua_luaQColor_QColor_dark00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int f = ((int)  tolua_tonumber(tolua_S,2,200));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dark'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->dark(f);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dark'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: darker of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_darker00
static int tolua_luaQColor_QColor_darker00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
  int f = ((int)  tolua_tonumber(tolua_S,2,200));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'darker'", NULL);
#endif
  {
   QColor tolua_ret = (QColor)  self->darker(f);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QColor)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QColor));
     tolua_pushusertype(tolua_S,tolua_obj,"QColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'darker'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operatorQVariant of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor__QVariant00
static int tolua_luaQColor_QColor__QVariant00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QColor* self = (const QColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operatorQVariant'", NULL);
#endif
  {
   QVariant tolua_ret = (QVariant)  self->operator  QVariant();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVariant)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVariant");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVariant));
     tolua_pushusertype(tolua_S,tolua_obj,"QVariant");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.QVariant'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isValidColor of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_isValidColor00
static int tolua_luaQColor_QColor_isValidColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* name = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  QColor::isValidColor(*name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isValidColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isValidColor of class  QColor */
#ifndef TOLUA_DISABLE_tolua_luaQColor_QColor_isValidColor01
static int tolua_luaQColor_QColor_isValidColor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QColor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String tolua_var_1 = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  QColor::isValidColor(tolua_var_1);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQColor_QColor_isValidColor00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_luaQColor_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"QColor","QColor","",tolua_collect_QColor);
  #else
  tolua_cclass(tolua_S,"QColor","QColor","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"QColor");
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new00);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new00_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new00_local);
   tolua_constant(tolua_S,"Invalid",QColor::Invalid);
   tolua_constant(tolua_S,"Rgb",QColor::Rgb);
   tolua_constant(tolua_S,"Hsv",QColor::Hsv);
   tolua_constant(tolua_S,"Cmyk",QColor::Cmyk);
   tolua_constant(tolua_S,"Hsl",QColor::Hsl);
   tolua_constant(tolua_S,"HexRgb",QColor::HexRgb);
   tolua_constant(tolua_S,"HexArgb",QColor::HexArgb);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new01);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new01_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new01_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new02);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new02_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new02_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new03);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new03_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new03_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new04);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new04_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new04_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new05);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new05_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new05_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new06);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new06_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new06_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new07);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new07_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new07_local);
   tolua_function(tolua_S,"new",tolua_luaQColor_QColor_new08);
   tolua_function(tolua_S,"new_local",tolua_luaQColor_QColor_new08_local);
   tolua_function(tolua_S,".call",tolua_luaQColor_QColor_new08_local);
   tolua_function(tolua_S,"isValid",tolua_luaQColor_QColor_isValid00);
   tolua_function(tolua_S,"name",tolua_luaQColor_QColor_name00);
   tolua_function(tolua_S,"name",tolua_luaQColor_QColor_name01);
   tolua_function(tolua_S,"setNamedColor",tolua_luaQColor_QColor_setNamedColor00);
   tolua_function(tolua_S,"setNamedColor",tolua_luaQColor_QColor_setNamedColor01);
   tolua_function(tolua_S,"colorNames",tolua_luaQColor_QColor_colorNames00);
   tolua_function(tolua_S,"alpha",tolua_luaQColor_QColor_alpha00);
   tolua_function(tolua_S,"setAlpha",tolua_luaQColor_QColor_setAlpha00);
   tolua_function(tolua_S,"alphaF",tolua_luaQColor_QColor_alphaF00);
   tolua_function(tolua_S,"setAlphaF",tolua_luaQColor_QColor_setAlphaF00);
   tolua_function(tolua_S,"red",tolua_luaQColor_QColor_red00);
   tolua_function(tolua_S,"green",tolua_luaQColor_QColor_green00);
   tolua_function(tolua_S,"blue",tolua_luaQColor_QColor_blue00);
   tolua_function(tolua_S,"setRed",tolua_luaQColor_QColor_setRed00);
   tolua_function(tolua_S,"setGreen",tolua_luaQColor_QColor_setGreen00);
   tolua_function(tolua_S,"setBlue",tolua_luaQColor_QColor_setBlue00);
   tolua_function(tolua_S,"redF",tolua_luaQColor_QColor_redF00);
   tolua_function(tolua_S,"greenF",tolua_luaQColor_QColor_greenF00);
   tolua_function(tolua_S,"blueF",tolua_luaQColor_QColor_blueF00);
   tolua_function(tolua_S,"setRedF",tolua_luaQColor_QColor_setRedF00);
   tolua_function(tolua_S,"setGreenF",tolua_luaQColor_QColor_setGreenF00);
   tolua_function(tolua_S,"setBlueF",tolua_luaQColor_QColor_setBlueF00);
   tolua_function(tolua_S,"getRgb",tolua_luaQColor_QColor_getRgb00);
   tolua_function(tolua_S,"setRgb",tolua_luaQColor_QColor_setRgb00);
   tolua_function(tolua_S,"getRgbF",tolua_luaQColor_QColor_getRgbF00);
   tolua_function(tolua_S,"setRgbF",tolua_luaQColor_QColor_setRgbF00);
   tolua_function(tolua_S,"rgba64",tolua_luaQColor_QColor_rgba6400);
   tolua_function(tolua_S,"setRgba64",tolua_luaQColor_QColor_setRgba6400);
   tolua_function(tolua_S,"rgba",tolua_luaQColor_QColor_rgba00);
   tolua_function(tolua_S,"setRgba",tolua_luaQColor_QColor_setRgba00);
   tolua_function(tolua_S,"rgb",tolua_luaQColor_QColor_rgb00);
   tolua_function(tolua_S,"setRgb",tolua_luaQColor_QColor_setRgb01);
   tolua_function(tolua_S,"hue",tolua_luaQColor_QColor_hue00);
   tolua_function(tolua_S,"saturation",tolua_luaQColor_QColor_saturation00);
   tolua_function(tolua_S,"hsvHue",tolua_luaQColor_QColor_hsvHue00);
   tolua_function(tolua_S,"hsvSaturation",tolua_luaQColor_QColor_hsvSaturation00);
   tolua_function(tolua_S,"value",tolua_luaQColor_QColor_value00);
   tolua_function(tolua_S,"hueF",tolua_luaQColor_QColor_hueF00);
   tolua_function(tolua_S,"saturationF",tolua_luaQColor_QColor_saturationF00);
   tolua_function(tolua_S,"hsvHueF",tolua_luaQColor_QColor_hsvHueF00);
   tolua_function(tolua_S,"hsvSaturationF",tolua_luaQColor_QColor_hsvSaturationF00);
   tolua_function(tolua_S,"valueF",tolua_luaQColor_QColor_valueF00);
   tolua_function(tolua_S,"getHsv",tolua_luaQColor_QColor_getHsv00);
   tolua_function(tolua_S,"setHsv",tolua_luaQColor_QColor_setHsv00);
   tolua_function(tolua_S,"getHsvF",tolua_luaQColor_QColor_getHsvF00);
   tolua_function(tolua_S,"setHsvF",tolua_luaQColor_QColor_setHsvF00);
   tolua_function(tolua_S,"cyan",tolua_luaQColor_QColor_cyan00);
   tolua_function(tolua_S,"magenta",tolua_luaQColor_QColor_magenta00);
   tolua_function(tolua_S,"yellow",tolua_luaQColor_QColor_yellow00);
   tolua_function(tolua_S,"black",tolua_luaQColor_QColor_black00);
   tolua_function(tolua_S,"cyanF",tolua_luaQColor_QColor_cyanF00);
   tolua_function(tolua_S,"magentaF",tolua_luaQColor_QColor_magentaF00);
   tolua_function(tolua_S,"yellowF",tolua_luaQColor_QColor_yellowF00);
   tolua_function(tolua_S,"blackF",tolua_luaQColor_QColor_blackF00);
   tolua_function(tolua_S,"getCmyk",tolua_luaQColor_QColor_getCmyk00);
   tolua_function(tolua_S,"setCmyk",tolua_luaQColor_QColor_setCmyk00);
   tolua_function(tolua_S,"getCmykF",tolua_luaQColor_QColor_getCmykF00);
   tolua_function(tolua_S,"setCmykF",tolua_luaQColor_QColor_setCmykF00);
   tolua_function(tolua_S,"hslHue",tolua_luaQColor_QColor_hslHue00);
   tolua_function(tolua_S,"hslSaturation",tolua_luaQColor_QColor_hslSaturation00);
   tolua_function(tolua_S,"lightness",tolua_luaQColor_QColor_lightness00);
   tolua_function(tolua_S,"hslHueF",tolua_luaQColor_QColor_hslHueF00);
   tolua_function(tolua_S,"hslSaturationF",tolua_luaQColor_QColor_hslSaturationF00);
   tolua_function(tolua_S,"lightnessF",tolua_luaQColor_QColor_lightnessF00);
   tolua_function(tolua_S,"getHsl",tolua_luaQColor_QColor_getHsl00);
   tolua_function(tolua_S,"setHsl",tolua_luaQColor_QColor_setHsl00);
   tolua_function(tolua_S,"getHslF",tolua_luaQColor_QColor_getHslF00);
   tolua_function(tolua_S,"setHslF",tolua_luaQColor_QColor_setHslF00);
   tolua_function(tolua_S,"toRgb",tolua_luaQColor_QColor_toRgb00);
   tolua_function(tolua_S,"toHsv",tolua_luaQColor_QColor_toHsv00);
   tolua_function(tolua_S,"toCmyk",tolua_luaQColor_QColor_toCmyk00);
   tolua_function(tolua_S,"toHsl",tolua_luaQColor_QColor_toHsl00);
   tolua_function(tolua_S,"convertTo",tolua_luaQColor_QColor_convertTo00);
   tolua_function(tolua_S,"fromRgb",tolua_luaQColor_QColor_fromRgb00);
   tolua_function(tolua_S,"fromRgba",tolua_luaQColor_QColor_fromRgba00);
   tolua_function(tolua_S,"fromRgb",tolua_luaQColor_QColor_fromRgb01);
   tolua_function(tolua_S,"fromRgbF",tolua_luaQColor_QColor_fromRgbF00);
   tolua_function(tolua_S,"fromRgba64",tolua_luaQColor_QColor_fromRgba6400);
   tolua_function(tolua_S,"fromRgba64",tolua_luaQColor_QColor_fromRgba6401);
   tolua_function(tolua_S,"fromHsv",tolua_luaQColor_QColor_fromHsv00);
   tolua_function(tolua_S,"fromHsvF",tolua_luaQColor_QColor_fromHsvF00);
   tolua_function(tolua_S,"fromCmyk",tolua_luaQColor_QColor_fromCmyk00);
   tolua_function(tolua_S,"fromCmykF",tolua_luaQColor_QColor_fromCmykF00);
   tolua_function(tolua_S,"fromHsl",tolua_luaQColor_QColor_fromHsl00);
   tolua_function(tolua_S,"fromHslF",tolua_luaQColor_QColor_fromHslF00);
   tolua_function(tolua_S,"light",tolua_luaQColor_QColor_light00);
   tolua_function(tolua_S,"lighter",tolua_luaQColor_QColor_lighter00);
   tolua_function(tolua_S,"dark",tolua_luaQColor_QColor_dark00);
   tolua_function(tolua_S,"darker",tolua_luaQColor_QColor_darker00);
   tolua_function(tolua_S,".QVariant",tolua_luaQColor_QColor__QVariant00);
   tolua_function(tolua_S,"isValidColor",tolua_luaQColor_QColor_isValidColor00);
   tolua_function(tolua_S,"isValidColor",tolua_luaQColor_QColor_isValidColor01);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_luaQColor (lua_State* tolua_S) {
 return tolua_luaQColor_open(tolua_S);
};
#endif

